\section{Decisiones}

Las dos primeras decisiones que se tomaron al comenzar el proyecto
fueron el lenguaje de programación a utilizar y la plataforma sobre la que se 
implementaría. No fue una tarea difícil tomar dichas decisiones:

\begin{itemize}
\item
Plataforma \textbf{Unix/Linux}
\item
Lenguaje de programación \textbf{Perl}
\end{itemize}

\subsection{¿Por qué Unix/Linux?}

Le experiencia nos muestra que la gran mayoría de los usuarios a los que
va destinada nuestra herramienta, desarrolla sus proyectos en entornos
Unix/Linux utilizando lenguajes como C, C++ o FORTRAN.

Por otro lado, existen entornos como \textit{Cygwin} que permiten
portar software que se ejecuta en sistemas \textit{POSIX} a sistemas 
\textit{Windows}. Es por ello que se ha escogido la plataforma 
\textbf{Unix/Linux} para el desarrollo de este proyecto.

\subsection{¿Por qué Perl?}

Como su nombre indica, \textbf{Perl} (\textit{Practical Extraction and Report Language})
es un lenguaje de propósito general originalmente desarrollado para
la manipulación de texto y que ahora es utilizado para un amplio rango
de tareas, incluyendo administración de sistemas, desarrollo web,
programación en red y desarrollo de interfaces de usuario (\textit{GUI}).

Se previó que fuera práctico (facilidad de uso, eficiente y completo)
en lugar de hermoso (pequeño, elegante y mínimo). Sus principales
características son la facilidad de uso, el soporte para programación
estructurada, programación orientada a objetos y programación
funcional. Además, tiene incorporado un poderoso sistema de
procesamiento de texto basado en expresiones regulares y dispone de
un enorme repositorio mundial, conocido como \textbf{CPAN} (\textit{Comprehensive
Perl Archive Network}), en donde programadores de todo el mundo 
comparten su trabajo.

Otra gran virtud de \textbf{Perl} es que viene incluido en la gran mayoría
de las distribuciones Unix/Linux actuales. Por otro lado, también
dispone de versiones para sistemas \textbf{Microsoft} y \textbf{MacOS} entre otros.

Como se verá durante el desarrollo de esta memoria, estas
características se ajustan perfectamente a las necesidades de
este proyecto:

\begin{itemize}
\item
Programación orientada a objetos.
\item
Ejecución en máquina local y máquinas remotas.
\item
Manipulación de textos y filtrado mediante expresiones regulares.
\item
Elaboración de informes en distintos formatos.
\end{itemize}

\section{Diagrama de clases}

Durante el desarrollo de la herramienta \texttt{Bench::Test} se ha
intentado seguir un diseño \textbf{MVC} (Modelo Vista Controlador) 
haciendo uso del paradigma de programación orientada a objetos 
separando el acceso a datos, y el procesamiento de los mismos, de la
presentación al usuario.

El acceso a datos, en este caso las salidas resultado de las
ejecuciones, se realiza mediante tres clases en las que se
basa el mecanismo de ejecución de los tests:
\texttt{Bench::Test::Base}, \texttt{Bench::Test::Local} y
\texttt{Bench::Test::Remote}. Cuando el acceso es a los resultados
de ejecuciones anteriores se utiliza la primera, para ejecuciones en
máquina local, la segunda, y para ejecuciones en máquinas remotas,
la tercera. Este acceso se realiza invocando al método \texttt{get\_result} de
la clase en cuestión.

A medida que se realizan las ejecuciones, la clase
\texttt{Bench::Test::View} va recolectando los resultados
para posteriormente darles el formato correspondiente y
presentarle al usuario una visión formateada de los mismos.

\begin{figure}
  \centering
    \includegraphics[width=\textwidth]{images/classdiagram.png}
  \caption{Diagrama de clases}
  \label{fig:classdiagram}
\end{figure}

En la figura \ref{fig:classdiagram} se muestra el
diagrama de clases asociado al proyecto.

\section{Diagrama de secuencia}

En la figura~\ref{fig:seqdiagram} se muestra el diagrama de
secuencia asociado a la ejecución de cada uno de los tests.

%\clearpage

\begin{figure}
  \centering
   \includegraphics[width=\textwidth]{images/seqdiagram.png}
  \caption{Diagrama de secuencia para la ejecución de un test}
  \label{fig:seqdiagram}
\end{figure}

El objeto \texttt{Bench::Test} invoca el método \texttt{get\_result} de cada
uno de los objetos \texttt{Bench::Test::Base}, \texttt{Bench::Test::Local} y
\texttt{Bench::Test::Remote} de que dispone y cuando ha obtenido de todos los
resultados envía una fila de datos al objeto \texttt{Bench::Test::View}
(invocando el método \texttt{add\_row}) que se encargará de
almacenarla. Una vez finalizados todos los tests, se podrá acceder
al resultado correctamente formateada mediante una llamada al método
\texttt{process} indicando el formato deseado en su parámetro
\texttt{format}.

\section{Modelo Vista Controlador}

Para la realización de este proyecto se ha intentado hacer una pequeña
aproximación al \textit{Modelo Vista Controlador}. Sin embargo, algunos
aspectos de este modelo quedan fuera del alcance de \texttt{Bench::Test}
puesto que no se cuenta con una interfaz gráfica que permita al usuario
interactuar con el sistema. A continuación se hace una breve introducción
al modelo.

Modelo Vista Controlador (\textit{MVC}) es un patrón de arquitectura de software
que separa los datos de una aplicación, la interfaz de usuario, y la lógica
de control en tres componentes distintos. Aunque el patrón \textbf{MVC} se ve
frecuentemente en aplicaciones web, donde la vista es la página HTML y el código
que provee de datos dinámicos a la página, también puede ser aplicado a muchos
otros tipos de aplicaciones.

\begin{description}

\item[{\textbf{Modelo:}}] \mbox{}

Ésta es la representación específica del dominio de la información sobre la
cual funciona la aplicación. El modelo es otra forma de llamar a la capa de
dominio. La lógica de dominio añade significado a los datos; por ejemplo,
calculando si hoy es el cumpleaños del usuario o los totales, impuestos o
portes en un carrito de la compra.

\item[{\textbf{Vista:}}] \mbox{}

Ésta presenta el modelo en un formato adecuado para interactuar, usualmente
un elemento de interfaz de usuario.

\item[{\textbf{Controlador:}}] \mbox{}

Éste responde a eventos, usualmente acciones del usuario e invoca cambios
en el modelo y probablemente en la vista.

\end{description}

Es común pensar que una aplicación tiene tres capas principales: presentación,
dominio, y acceso a datos. En \textbf{MVC}, la capa de presentación está partida
en controlador y vista. La principal separación es entre presentación y
dominio; la separación entre V/C es menos clara.

Aunque se pueden encontrar diferentes implementaciones de \textbf{MVC}, el flujo que
sigue el control generalmente es el siguiente:

\begin{enumerate}
\item
El usuario interactúa con la interfaz de usuario de alguna forma
(por ejemplo, pulsando un botón o especificando alguna entrada).
\item
El controlador recibe (por parte de los objetos de la interfaz-vista) la
notificación de la acción solicitada por el usuario. El controlador gestiona
el evento que llega, frecuentemente a través de un gestor de eventos (handler)
o callback.
\item
El controlador accede al modelo, actualizándolo, posiblemente modificándolo
de forma adecuada a la acción solicitada por el usuario (por ejemplo, el
controlador actualiza el carro de la compra del usuario). Los controladores
complejos están a menudo estructurados usando un patrón de comando que
encapsula las acciones y simplifica su extensión.
\item
El controlador delega a los objetos de la vista la tarea de desplegar la
interfaz de usuario. La vista obtiene sus datos del modelo para generar
la interfaz apropiada para el usuario donde se refleja los cambios en el
modelo (por ejemplo, produce un listado del contenido del carro de la compra).
El modelo no debe tener conocimiento directo sobre la vista. Sin embargo,
el patrón de observador puede ser utilizado para proveer cierta indirección
entre el modelo y la vista, permitiendo al modelo notificar a los interesados
de cualquier cambio. Un objeto vista puede registrarse con el modelo y esperar
a los cambios, pero aun así el modelo en sí mismo sigue sin saber nada de la
vista. El controlador no pasa objetos de dominio (el modelo) a la vista aunque
puede dar la orden a la vista para que se actualice.
\item
La interfaz de usuario espera nuevas interacciones del usuario, comenzando
el ciclo nuevamente.
\end{enumerate}
